home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / dev / misc / LEDA_src.lha / LEDA-3.1c-source / src / vga.old / _vgawin.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-17  |  24.6 KB  |  1,116 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _vgawin.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. #include "vgalib.h"
  18.  
  19. /*----------------------------------------------------------------------------*/
  20. /* event handling, window manager, etc ...                                    */
  21. /*----------------------------------------------------------------------------*/
  22.  
  23. #define BORDER_W 5
  24. #define HEADER_W 20 
  25.  
  26. static int display = 0;
  27. static int mouse_installed=0;
  28. static int mouse_two_buttons=0;
  29.  
  30. static Window root_win = 0;
  31. static Window  win_stack[16];
  32. static int win_top = 0;
  33.  
  34. static int root_color = 14; // grey 
  35.  
  36. static int pointer_shape = 0;
  37. static int mouse_x = DISP_WIDTH/2;
  38. static int mouse_y = DISP_HEIGHT/2;
  39.  
  40. static int event_buffer_e = -1;
  41. static int event_buffer_val;
  42. static Window event_buffer_win;
  43.  
  44. static int last_event_e;
  45. static int last_event_val;
  46. static Window last_event_win;
  47.  
  48. static int pointer_visible = 0;
  49.  
  50. static int save_mode;
  51. static int save_lw;
  52. static int save_ls;
  53.  
  54.  
  55. static unsigned char pointer_mask[2][2][14] = { 
  56. {{0xc0,0xf0,0x7c,0x7f,0x3f,0x3f,0x1f,0x1f,0x0d,0x0c,0x00,0x00,0x00,0x00},
  57.  {0x00,0x00,0x00,0x00,0xc0,0xc0,0x00,0x80,0xc0,0xe0,0x70,0x38,0x1c,0x0c}},
  58.  
  59. {{0x00,0x00,0x00,0x00,0x03,0x03,0x00,0x01,0x03,0x07,0x0e,0x1c,0x38,0x30},
  60.  {0x03,0x0f,0x3e,0xfe,0xfc,0xfc,0xf8,0xf8,0xb0,0x30,0x00,0x00,0x00,0x00} }
  61. };
  62.  
  63.  
  64. static void draw_pointer()
  65. {
  66.   register int x1 = mouse_x % 8;
  67.   register int x2 = 8-x1;
  68.   register int x = mouse_x/8;
  69.   VIDEO_PTR start = VIDEO + LINE_BYTES*mouse_y + x;
  70.   register VIDEO_PTR q;
  71.   register unsigned char c;
  72.  
  73.   set_color(black);
  74.  
  75.   if (pointer_shape == 1)
  76.   { pixel(root_win,mouse_x-2,mouse_y);
  77.     pixel(root_win,mouse_x-1,mouse_y);
  78.     pixel(root_win,mouse_x,mouse_y);
  79.     pixel(root_win,mouse_x+1,mouse_y);
  80.     pixel(root_win,mouse_x+3,mouse_y);
  81.     pixel(root_win,mouse_x,mouse_y-2);
  82.     pixel(root_win,mouse_x,mouse_y-1);
  83.     pixel(root_win,mouse_x,mouse_y+1);
  84.     pixel(root_win,mouse_x,mouse_y+2);
  85.     circle(root_win,mouse_x,mouse_y,6);
  86.     return;
  87.    }
  88.  
  89.  
  90.   int a = 0;
  91.   int b = 14;
  92.   int d = 1;
  93.   int k = 0;
  94.  
  95.   if (mouse_y + 15 > DISP_MAX_Y) 
  96.   { a = 13;
  97.     b = -1;
  98.     d = -1;
  99.     start -= 14*LINE_BYTES;
  100.    }
  101.  
  102.   if (x > 77) 
  103.   { start -= 2;
  104.     k = 1;
  105.    }
  106.  
  107.   port_out(8, GRA_I);
  108.  
  109.   for(int i=a; i!=b; i+=d)
  110.   { q = start;
  111.     c = (pointer_mask[k][0][i]>>x1);
  112.     port_out(c, GRA_D);
  113.     *q = *q;
  114.     ++q; 
  115.     c = ((pointer_mask[k][1][i]>>x1) | (pointer_mask[k][0][i]<<x2));
  116.     port_out(c, GRA_D);
  117.     *q = *q;
  118.     
  119.     if (x2)
  120.     { ++q;
  121.       c = (pointer_mask[k][1][i]<<x2);
  122.       port_out(c, GRA_D);
  123.       *q = *q;
  124.      }
  125.     start+=LINE_BYTES;
  126.    }
  127. }
  128.  
  129. static void show_pointer()
  130. { if (!pointer_visible) draw_pointer(); 
  131.   pointer_visible = 1;
  132.  }
  133.  
  134. static void hide_pointer()
  135. { if (pointer_visible) draw_pointer(); 
  136.   pointer_visible = 0;
  137.  }
  138.  
  139.  
  140. static void set_pointer_shape(int shape)
  141. { if (pointer_shape != shape) 
  142.   { draw_pointer();
  143.     pointer_shape = shape;
  144.     draw_pointer();
  145.   }
  146.  }
  147.  
  148.  
  149. static void save_box(Window win)
  150. { register int y;
  151.   register VIDEO_PTR p;
  152.   register VIDEO_PTR q;
  153.   register VIDEO_PTR first;
  154.   register VIDEO_PTR last;
  155.  
  156.   if (win_top <= 1) { win->plane[0] = 0; return; }
  157.  
  158.   int left   = win->x0;
  159.   int top    = win->y0;
  160.   int right  = win->x1;
  161.   int bottom = win->y1;
  162.  
  163.   int i,l,r;
  164.  
  165.   if(left < 0) left = 0;
  166.   if(top  < 0) top = 0;
  167.   if(right  > DISP_MAX_X) right = DISP_MAX_X;
  168.   if(bottom > DISP_MAX_Y) bottom = DISP_MAX_Y;
  169.  
  170.   l = (left>>3);
  171.   r = (right>>3);
  172.  
  173.   win->plane[0] = (VIDEO_PTR)malloc((r-l+1)*(bottom-top+1));
  174.   win->plane[1] = (VIDEO_PTR)malloc((r-l+1)*(bottom-top+1));
  175.   win->plane[2] = (VIDEO_PTR)malloc((r-l+1)*(bottom-top+1));
  176.   win->plane[3] = (VIDEO_PTR)malloc((r-l+1)*(bottom-top+1));
  177.  
  178.   /* set read mode 0 */
  179.   port_out(5, GRA_I);
  180.   port_out(0, GRA_D);
  181.  
  182.   /* read planes 0 to 3 */
  183.   for(i=0; i<4; i++)
  184.   { p = win->plane[i];
  185.  
  186.     port_out(4, GRA_I);
  187.     port_out(i, GRA_D);
  188.  
  189.     first = VIDEO + LINE_BYTES*top + l;
  190.     last  = VIDEO + LINE_BYTES*top + r;
  191.  
  192.     for(y=top; y<=bottom; y++)
  193.     { for(q=first; q<=last; q++) *p++ = *q;
  194.       first  += LINE_BYTES;
  195.       last   += LINE_BYTES;
  196.      }
  197.   }
  198. }
  199.  
  200.  
  201.  
  202. static void restore_box(Window win, int left, int top, int right, int bottom)
  203. { register int y;
  204.   register VIDEO_PTR p;
  205.   register VIDEO_PTR q;
  206.   register VIDEO_PTR first;
  207.   register VIDEO_PTR last;
  208.   int save_mode;
  209.   int save_col;
  210.   int i;
  211.  
  212.   if(left < 0) left = 0;
  213.   if(top  < 0) top = 0;
  214.   if(right  > DISP_MAX_X) right = DISP_MAX_X;
  215.   if(bottom > DISP_MAX_Y) bottom = DISP_MAX_Y;
  216.  
  217.   save_mode = set_mode(0);
  218.  
  219.   if (win->plane[0])
  220.      save_col = set_color(0);
  221.   else
  222.      save_col = set_color(root_color);
  223.  
  224.  
  225.   // clean area
  226.  
  227.   port_out(8, GRA_I);
  228.   port_out(0xFF, GRA_D);
  229.   first  = VIDEO + LINE_BYTES*top + left/8;
  230.   last   = VIDEO + LINE_BYTES*top + right/8;
  231.   for(y=top; y<=bottom; y++)
  232.   { for(q=first; q<=last; q++) *q = *q;
  233.     first  += LINE_BYTES;
  234.     last   += LINE_BYTES;
  235.    }
  236.  
  237.  
  238.   // fill in plane data
  239.  
  240.   set_mode(2); /* or */
  241.  
  242.   if (win->plane[0])
  243.     for(i = 0; i < 4; i++)
  244.     {
  245.       p = win->plane[i];
  246.   
  247.       set_color(1<<i);
  248.   
  249.       first  = VIDEO + LINE_BYTES*top + left/8;
  250.       last   = VIDEO + LINE_BYTES*top + right/8;
  251.   
  252.       port_out(8, GRA_I);
  253.   
  254.       for(y=top; y<=bottom; y++)
  255.       { for(q=first; q<=last; q++,p++) 
  256.         { port_out(*p, GRA_D);
  257.           *q = *q;
  258.          }
  259.         first  += LINE_BYTES;
  260.         last   += LINE_BYTES;
  261.        }
  262.   
  263.       free((char*)win->plane[i]);
  264.     }
  265.   
  266.     set_mode(save_mode);
  267.     set_color(save_col);
  268. }
  269.  
  270.  
  271.  
  272. static void draw_window(Window win)
  273. {
  274.   int bw  = win->xpos - win->x0 - 2;
  275.   int lw  = win->ypos - win->y0 - 2;
  276.   int bw1 = 2*(bw+1);
  277.  
  278.   int x0 = win->x0;
  279.   int y0 = win->y0;
  280.  
  281.   int x1 = win->x1;
  282.   int y1 = win->y1;
  283.  
  284.   int save_mode = set_mode(0);
  285.  
  286.   set_color(win->bg_col);
  287.   box(root_win,x0,y0,x1,y1);
  288.   set_color(win->label_col);
  289.   box(root_win,x0+bw,y0+bw,x1-bw,y0+lw);
  290.   box(root_win,x0,y0+bw1,x0+bw,y1-bw1);
  291.   box(root_win,x1-bw,y0+bw1,x1,y1-bw1);
  292.   box(root_win,x0+bw1,y1-bw,x1-bw1,y1);
  293.   box(root_win,x0+bw1,y0,x1-bw1,y0+bw);
  294.   set_color(1);
  295.  
  296.   rectangle(root_win,x0,y0,x1,y1);
  297.  
  298.   line(root_win,x0+bw,y0+bw,x0+bw1,y0+bw);
  299.   line(root_win,x0+bw1,y0+bw,x0+bw1,y0+1);
  300.   line(root_win,x0+bw1,y0+1,x1-bw1,y0+1);
  301.   line(root_win,x1-bw1,y0+1,x1-bw1,y0+bw);
  302.   line(root_win,x1-bw1,y0+bw,x1-bw,y0+bw);
  303.   line(root_win,x1-bw,y0+bw,x1-bw,y0+bw1);
  304.   line(root_win,x1-bw,y0+bw1,x1-1,y0+bw1);
  305.   line(root_win,x1-1,y0+bw1,x1-1,y1-bw1);
  306.   line(root_win,x1-1,y1-bw1,x1-bw,y1-bw1);
  307.   line(root_win,x1-bw,y1-bw1,x1-bw,y1-bw);
  308.   line(root_win,x1-bw,y1-bw,x1-bw1,y1-bw);
  309.   line(root_win,x1-bw1,y1-bw,x1-bw1,y1-1);
  310.   line(root_win,x1-bw1,y1-1,x0+bw1,y1-1);
  311.   line(root_win,x0+bw1,y1-1,x0+bw1,y1-bw);
  312.   line(root_win,x0+bw1,y1-bw,x0+bw,y1-bw);
  313.   line(root_win,x0+bw,y1-bw,x0+bw,y1-bw1);
  314.   line(root_win,x0+bw,y1-bw1,x0+1,y1-bw1);
  315.   line(root_win,x0+1,y1-bw1,x0+1,y0+bw1);
  316.   line(root_win,x0+1,y0+bw1,x0+bw,y0+bw1);
  317.   line(root_win,x0+bw,y0+bw1,x0+bw,y0+bw);
  318.  
  319.   rectangle(root_win, win->xpos-1, win->ypos-1,
  320.                       win->xpos+win->width, win->ypos+win->height);
  321.  
  322.   // iconize-button
  323.   set_color(0);
  324.   box(root_win,x0+13,y0+3,x0+27,y0+15);
  325.   set_color(1);
  326.   rectangle(root_win,x0+13,y0+3,x0+27,y0+15);
  327.   line(root_win,x0+14,y0+16,x0+28,y0+16);
  328.   line(root_win,x0+28,y0+4,x0+28,y0+15);
  329.   line(root_win,x0+17,y0+6,x0+23,y0+6);
  330.   line(root_win,x0+16,y0+6,x0+20,y0+13);
  331.   line(root_win,x0+17,y0+6,x0+20,y0+13);
  332.   line(root_win,x0+24,y0+6,x0+20,y0+13);
  333.   line(root_win,x0+23,y0+6,x0+20,y0+13);
  334.  
  335.   set_header(win,win->header);
  336.  
  337.   set_mode(save_mode);
  338.  
  339. }
  340.  
  341.  
  342. Window open_window(int x,int y,int width,int height,const char* header,
  343.                                                     const char* label)
  344. { 
  345.   Window win = new vga_window;
  346.  
  347.   win_top++;
  348.   win_stack[win_top] = win;
  349.  
  350.   strcpy(win->header," ");
  351.   strcpy(win->label,label);
  352.  
  353.   if ( strcmp(label,"PANEL") == 0)
  354.      { win->bg_col = white; // grey
  355.        win->label_col = violet;
  356.       }
  357.   else
  358.      { win->bg_col = white;
  359.        win->label_col = yellow;
  360.       }
  361.  
  362.   width  += 2*BORDER_W;
  363.   height += HEADER_W+BORDER_W;
  364.  
  365.   if (width > DISP_WIDTH) width = DISP_WIDTH;
  366.   if (height > DISP_HEIGHT) height = DISP_HEIGHT;
  367.  
  368.   if (x+width > DISP_WIDTH) x = DISP_WIDTH - width;
  369.   if (x < 0) x = 0;
  370.   if (y+height > DISP_HEIGHT) y = DISP_HEIGHT - height;
  371.   if (y < 0) y = 0;
  372.  
  373.   win->x0 = x;
  374.   win->y0 = y;
  375.   win->x1 = x+width-1;
  376.   win->y1 = y+height-1;
  377.   win->xpos = x+BORDER_W;
  378.   win->ypos = y+HEADER_W;
  379.   win->width = width - 2*BORDER_W; 
  380.   win->height = height - HEADER_W - BORDER_W;
  381.  
  382.   win->iconized = 0;
  383.   win->save_x0 = 3;
  384.   win->save_y0 = 3 + 150*(win_top-1);
  385.   win->save_x1 = win->save_x0 + 128 + 2*BORDER_W;
  386.   win->save_y1 = win->save_y0 + 128 + HEADER_W + BORDER_W;
  387.   win->save_bg_col = white;
  388.  
  389.   save_box(win);
  390.   draw_window(win);
  391.   set_header(win,header);
  392.   return win;
  393. }
  394.  
  395.  
  396. void close_window(Window win)
  397. { win = win_stack[win_top];  /* can close top window only */
  398.   restore_box(win,win->x0,win->y0,win->x1,win->y1);
  399.   win_top--;
  400.   delete win;
  401.  }
  402.  
  403.  
  404.  
  405.  
  406.  
  407. void set_read_gc()
  408. { save_mode = set_mode(1);
  409.   save_ls   = set_line_style(0);
  410.   save_lw   = set_line_width(1);
  411.   set_color(1);
  412.   show_pointer();
  413.  }
  414.  
  415. void reset_gc()
  416. { hide_pointer();
  417.   set_mode(save_mode);
  418.   set_line_style(save_ls);
  419.   set_line_width(save_lw);
  420.  }
  421.  
  422.  
  423. #define UP  72
  424. #define DO  80
  425. #define LE  75
  426. #define RI  77
  427.  
  428. #define F1  59
  429. #define F2  60
  430. #define F3  61
  431. #define F4  62
  432. #define SF1 84
  433. #define SF2 85
  434. #define SF3 86
  435. #define CF1 94
  436. #define CF2 95
  437. #define CF3 96
  438.  
  439. char get_key()
  440. {
  441. #if defined(__GNUG__)
  442.   return getkey();
  443. #else
  444.   return getch();
  445. #endif
  446. }
  447.  
  448.  
  449. static int handle_next_event(Window *win, int *val, int *x, int *y)
  450. {
  451.   int  e =  no_event;
  452.   int  i;
  453.  
  454.   union REGS key_regs;
  455.   union REGS mouse_regs;
  456.  
  457.   if (event_buffer_e != -1)
  458.   { *val = event_buffer_val;
  459.     *win = event_buffer_win;
  460.     *x = mouse_x - (*win)->xpos;
  461.     *y = mouse_y - (*win)->ypos;
  462.     last_event_e = event_buffer_e;
  463.     last_event_val = event_buffer_val;
  464.     last_event_win = event_buffer_win;
  465.     event_buffer_e = -1;
  466.     return last_event_e;
  467.    }
  468.  
  469.   mouse_regs.x.cx = 8*mouse_x;
  470.   mouse_regs.x.dx = 8*mouse_y;
  471.  
  472.  
  473.   if (kbhit())
  474.   { 
  475.     int step = 8;
  476.  
  477.     char c = get_key();
  478.  
  479.     if (c==27) 
  480.     { close_display();
  481.       exit(0);
  482.      }
  483.  
  484.     if (c != 0)   /* ascii char */
  485.        { *val = c;
  486.          e = key_press_event;
  487.         }
  488.     else          /* cursor or function key  */
  489.        { 
  490.          c = get_key();
  491.  
  492.          switch(c) {
  493.  
  494.          case  LE: mouse_regs.x.cx -= step;
  495.                    e = motion_event;
  496.                    break;
  497.  
  498.          case  RI: mouse_regs.x.cx += step;
  499.                    e = motion_event;
  500.                    break;
  501.  
  502.          case  UP: mouse_regs.x.dx -= step;
  503.                    e = motion_event;
  504.                    break;
  505.  
  506.          case  DO: mouse_regs.x.dx += step;
  507.                    e = motion_event;
  508.                    break;
  509.  
  510.          case  F1: *val = 1;
  511.                    e = button_press_event;
  512.                    break;
  513.  
  514.          case  F2: *val = 2;
  515.                    e = button_press_event;
  516.                    break;
  517.  
  518.          case  F3: *val = 3;
  519.                    e = button_press_event;
  520.                    break;
  521.  
  522.          case  F4: *val = 1;
  523.                    e = button_release_event;
  524.                    break;
  525.  
  526.          case SF1: *val = -1;
  527.                    e = button_press_event;
  528.                    break;
  529.  
  530.          case SF2: *val = -2;
  531.                    e = button_press_event;
  532.                    break;
  533.  
  534.          case SF3: *val = -3;
  535.                    e = button_press_event;
  536.                    break;
  537.  
  538.          case CF1: *val = 4;
  539.                    e = button_press_event;
  540.                    break;
  541.  
  542.          case CF2: *val = 5;
  543.                    e = button_press_event;
  544.                    break;
  545.  
  546.          case  CF3: *val = 6;
  547.                    e = button_press_event;
  548.                    break;
  549.         }
  550.  
  551.         /* set cursor position */
  552.         mouse_regs.x.ax=04;
  553.         int86(0x33,&mouse_regs,&mouse_regs);
  554.       }
  555.  
  556.    } /* kbhit */
  557.  
  558.  else
  559.  
  560.   if (mouse_installed)
  561.   { 
  562.     int but;
  563.  
  564.     /* check for button press and release events */
  565.  
  566. //INT 33 - MS MOUSE - RETURN BUTTON PRESS DATA
  567. //    AX = 0005h
  568. //    BX = button
  569. //        0000h left
  570. //        0001h right
  571. //        0002h middle (Mouse Systems/Logitech mouse)
  572. //Return: AX = 1 if button pressed
  573. //      BX = number of times specified button has been pressed since last call
  574. //      CX = column at time specified button was last pressed
  575. //      DX = row at time specified button was last pressed
  576.  
  577. //INT 33 - MS MOUSE - RETURN BUTTON RELEASE DATA
  578. //    AX = 0006h
  579. //    BX = button
  580. //        0000h left
  581. //        0001h right
  582. //        0002h middle (Mouse Systems/Logitech mouse)
  583. //Return: AX = 1 if button released
  584. //      BX = # of times specified button has been released since last call
  585. //      CX = column at time specified button was last released
  586. //      DX = row at time specified button was last released
  587.  
  588.     for(but=0; but < 3; but++)
  589.     { 
  590.       mouse_regs.x.ax=5;
  591.       mouse_regs.x.bx=but;
  592.       int86(0x33,&mouse_regs,&mouse_regs);
  593.  
  594.       if (mouse_regs.x.bx)
  595.       { e = button_press_event;
  596.         break;
  597.        }
  598.  
  599.       mouse_regs.x.ax=6;
  600.       mouse_regs.x.bx=but;
  601.       int86(0x33,&mouse_regs,&mouse_regs);
  602.  
  603.       if (mouse_regs.x.bx)
  604.       { e = button_release_event;
  605.         break;
  606.        }
  607.  
  608.      }
  609.  
  610.  
  611.     if (but < 3) 
  612.     { 
  613.       if (but == 0) *val = 1;   // left
  614.       if (but == 1) *val = 3;   // right
  615.  
  616.       //INT 16 - GET KEYBOARD SHIFT KEY STATES
  617.       //          AH = 0002h
  618.       //  OUTPUT: AL  bit 0    right shift
  619.       //              bit 1    left shift
  620.       //              bit 2    ctrl
  621.       //              bit 3    alt
  622.  
  623.       key_regs.h.ah=0x02;
  624.       int86(0x16,&key_regs,&key_regs);
  625.  
  626.       // ALT key simulates middle button  (two-button mouse)
  627.       if (key_regs.h.al & 8) *val = 2; 
  628.  
  629.       if (key_regs.h.al & 3) *val = -*val;   /* shift */
  630.       if (key_regs.h.al & 4) *val += 3;      /* ctrl  */
  631.      }
  632.  
  633.    // INT 33 MS-MOUSE GET CURSOR POSITION
  634.    mouse_regs.x.ax=03;
  635.    int86(0x33,&mouse_regs,&mouse_regs);
  636.   }
  637.  
  638.   if (mouse_regs.x.cx/8 != mouse_x || mouse_regs.x.dx/8 != mouse_y)
  639.   { if (e==no_event) e = motion_event;
  640.     draw_pointer();
  641.     mouse_y = mouse_regs.x.dx/8;
  642.     mouse_x = mouse_regs.x.cx/8;
  643.     draw_pointer();
  644.    }
  645.  
  646.   for(i = win_top; i >= 0; i--)
  647.   { Window w = win_stack[i];
  648.     if (mouse_x >= w->x0  && mouse_x <= w->x1 &&
  649.         mouse_y >= w->y0  && mouse_y <= w->y1 )  break;
  650.    }
  651.  
  652.   *win = win_stack[i];
  653.   *x = mouse_x - (*win)->xpos;
  654.   *y = mouse_y - (*win)->ypos;
  655.  
  656.   if (e != no_event)
  657.   { last_event_e   = e;
  658.     last_event_val = *val;
  659.     last_event_win = *win;
  660.    }
  661.  
  662.   return e;
  663.  }
  664.  
  665.  
  666. void put_back_event() 
  667. { event_buffer_e   = last_event_e;  
  668.   event_buffer_val = last_event_val; 
  669.   event_buffer_win = last_event_win; 
  670.  }
  671.  
  672. static void change_geometry(Window win, int x0, int y0, int x1, int y1)
  673. {
  674.   if (x0==win->x0 && y0==win->y0 && x1==win->x1 && y1==win->y1) return;
  675.  
  676.   int w = x1-x0+1;
  677.   int h = y1-y0+1;
  678.  
  679.   draw_pointer();
  680.   restore_box(win,win->x0,win->y0,win->x1,win->y1);
  681.  
  682.   win->x0 = x0;
  683.   win->y0 = y0;
  684.   win->x1 = x1;
  685.   win->y1 = y1;
  686.   win->xpos = x0+BORDER_W;
  687.   win->ypos = y0+HEADER_W;
  688.   win->width = w - 2*BORDER_W; 
  689.   win->height = h - HEADER_W - BORDER_W;
  690.  
  691.   save_box(win);
  692.   draw_window(win);
  693.   draw_pointer();
  694. }
  695.  
  696.  
  697. static void iconize(Window win)
  698. { Window w;
  699.   int val,x,y;
  700.   box(root_win,win->x0+14,win->y0+4,win->x0+26,win->y0+14);
  701.   while (handle_next_event(&w,&val,&x,&y) != button_release_event);
  702.   box(root_win,win->x0+14,win->y0+4,win->x0+26,win->y0+14);
  703.  
  704.   int x0 = win->save_x0;
  705.   int y0 = win->save_y0;
  706.   int x1 = win->save_x1;
  707.   int y1 = win->save_y1;
  708.   int bg = win->save_bg_col;
  709.   win->save_x0 = win->x0;
  710.   win->save_y0 = win->y0;
  711.   win->save_x1 = win->x1;
  712.   win->save_y1 = win->y1;
  713.   win->save_bg_col = win->bg_col;
  714.   win->bg_col =  bg;
  715.   change_geometry(win,x0,y0,x1,y1);
  716.   win->iconized = 1-win->iconized;
  717.  
  718.   if (win->iconized) 
  719.      insert_bitmap(win, leda_icon_width, leda_icon_height, leda_icon_bits);
  720.  }
  721.  
  722. static void move_win(Window win, int *x, int *y)
  723. { int xp0 = win->x0;
  724.   int yp0 = win->y0;
  725.   int xp1 = win->x1;
  726.   int yp1 = win->y1;
  727.   int wi  = xp1-xp0+1;
  728.   int he  = yp1-yp0+1;
  729.   int xb  = win->xpos - xp0;
  730.   int yb  = win->ypos - yp0;
  731.   int xc = mouse_x; /* absolute cursor coordinates */
  732.   int yc = mouse_y; 
  733.   int dx = xc-xp0;  /* relative to upper left corner */
  734.   int dy = yc-yp0;
  735.  
  736.   Window w;
  737.   int e,val;
  738.  
  739.   rectangle(root_win,xp0-1,yp0-1,xp1+1,yp1+1);
  740.  
  741.   do { e = handle_next_event(&w,&val,x,y);
  742.       if (mouse_x != xc || mouse_y != yc)
  743.        { int rx0 = mouse_x-dx-1;
  744.          int ry0 = mouse_y-dy-1;
  745.          int rx1 = mouse_x-dx+wi;
  746.          int ry1 = mouse_y-dy+he;
  747.          rectangle(root_win,rx0,ry0,rx1,ry1);
  748.          rectangle(root_win,xc-dx-1,yc-dy-1,xc-dx+wi,yc-dy+he);
  749.          xc = mouse_x;
  750.          yc = mouse_y;
  751.        }
  752.      } while (e != button_release_event);
  753.  
  754.   xc -= dx;
  755.   yc -= dy;
  756.  
  757.   rectangle(root_win,xc-1,yc-1,xc+wi,yc+he);
  758.  
  759.   if (xc < 0) xc = 0;
  760.   if (yc < 0) yc = 0;
  761.   if (xc + wi > DISP_MAX_X) xc = DISP_MAX_X - wi;
  762.   if (yc + he > DISP_MAX_Y) yc = DISP_MAX_Y - he;
  763.  
  764.   if (win_top > 1)  /* move panel */
  765.   { change_geometry(win,xc,yc,xc+wi-1,yc+he-1);
  766.     if (win->iconized) 
  767.        insert_bitmap(win, leda_icon_width, leda_icon_height, leda_icon_bits);
  768.     return;
  769.    }
  770.  
  771.   xc -= xc % 8;
  772.   xc += xp0 % 8;
  773.  
  774.   draw_pointer();
  775.   copy_rect(root_win,xp0,yp0+1,xp0+wi,yp0+he-1,xc,yc+1);
  776.   draw_pointer();
  777.  
  778.   set_mode(0);
  779.   set_color(root_color);
  780.  
  781.   if (xc > xp0) 
  782.      box(root_win,xp0,yp0,xc-1,yp1);
  783.   else
  784.      box(root_win,xc+wi,yp0,xp1,yp1);
  785.  
  786.   if (yc > yp0) 
  787.      box(root_win,xp0,yp0,xp1,yc-1);
  788.   else
  789.      box(root_win,xp0,yc+he,xp1,yp1);
  790.  
  791.   set_color(1);
  792.   rectangle(root_win,xc,yc,xc+wi-1,yc+he-1);
  793.  
  794.   set_mode(1);
  795.  
  796.   win->x0 = xc; 
  797.   win->y0 = yc; 
  798.   win->x1 = xc+wi-1; 
  799.   win->y1 = yc+he-1; 
  800.   win->xpos = xc+xb; 
  801.   win->ypos = yc+yb; 
  802.  
  803. }
  804.  
  805.  
  806. static void resize_win(Window win, int* x, int* y, int pos)
  807. { int xp0 = win->x0;
  808.   int yp0 = win->y0;
  809.   int xp1 = win->x1;
  810.   int yp1 = win->y1;
  811.   int xb  = win->xpos - xp0;
  812.   int yb  = win->ypos - yp0;
  813.   
  814.   int xc  = mouse_x; /* absolute cursor coordinates */
  815.   int yc  = mouse_y;
  816.  
  817.   Window w;
  818.   int e,val,dx,dy;
  819.  
  820.   rectangle(root_win,xp0-1,yp0-1,xp1+1,yp1+1);
  821.  
  822.   switch(pos) {
  823.   
  824.    case 0: dx = xp0-xc;          /* upper left */
  825.            dy = yp0-yc;
  826.            break;
  827.  
  828.    case 1: dx = xp1-xc;          /* upper right */
  829.            dy = yp0-yc;
  830.            break;
  831.  
  832.    case 2: dx = xp1-xc;          /* lower right */
  833.            dy = yp1-yc;
  834.            break;
  835.  
  836.    case 3: dx = xp0-xc;          /* lower left */
  837.            dy = yp1-yc;
  838.            break;
  839.  
  840.    }
  841.  
  842.   do { e = handle_next_event(&w,&val,x,y);
  843.       if (mouse_x != xc || mouse_y != yc)
  844.          { 
  845.            switch(pos) {
  846.  
  847.            case 0: rectangle(root_win,mouse_x+dx-1,mouse_y+dy-1,xp1+1,yp1+1);
  848.                    rectangle(root_win,xc+dx-1,yc+dy-1,xp1+1,yp1+1);
  849.                    break;
  850.            
  851.            case 1: rectangle(root_win,xp0-1,mouse_y+dy-1,mouse_x+dx+1,yp1+1);
  852.                    rectangle(root_win,xp0-1,yc+dy-1,xc+dx+1,yp1+1);
  853.                    break;
  854.  
  855.            case 2: rectangle(root_win,xp0-1,yp0-1,mouse_x+dx+1,mouse_y+dy+1);
  856.                    rectangle(root_win,xp0-1,yp0-1,xc+dx+1,yc+dy+1);
  857.                    break;
  858.               
  859.            case 3: rectangle(root_win,mouse_x+dx-1,yp0-1,xp1+1,mouse_y+dy+1);
  860.                    rectangle(root_win,xc+dx-1,yp0-1,xp1+1,yc+dy+1);
  861.                    break;
  862.            
  863.             }
  864.  
  865.            xc = mouse_x;
  866.            yc = mouse_y;
  867.          }
  868.      } while (e != button_release_event);
  869.  
  870.    xc += dx;
  871.    yc += dy;
  872.  
  873.    switch(pos) {
  874.  
  875.    case 0: win->x0 = xc; 
  876.            win->y0 = yc; 
  877.            break;
  878.                 
  879.    case 1: win->x1 = xc; 
  880.            win->y0 = yc; 
  881.            break;
  882.               
  883.    case 2: win->x1 = xc; 
  884.            win->y1 = yc; 
  885.            break;
  886.  
  887.    case 3: win->x0 = xc; 
  888.            win->y1 = yc; 
  889.            break;
  890.            
  891.    }
  892.  
  893.   win->xpos = win->x0 + xb;
  894.   win->ypos = win->y0 + yb;
  895.   win->width  = win->x1 - win->x0 - 2*xb + 1; 
  896.   win->height = win->y1 - win->y0 - xb - yb + 1; 
  897.  
  898.   rectangle(root_win,win->x0-1,win->y0-1,win->x1+1,win->y1+1);
  899.  
  900.   draw_pointer();
  901.  
  902.   restore_box(win,xp0,yp0,xp1,yp1);
  903.  
  904.   save_box(win);
  905.  
  906.   draw_window(win);
  907.  
  908.   draw_pointer();
  909.  
  910.   *x = win->width;
  911.   *y = win->height;
  912.  
  913. }
  914.  
  915.  
  916. int check_next_event(Window* win, int* val, int* x, int *y, unsigned long* t)
  917. {
  918.   // non-blocking
  919.   
  920.   // a primitive window manager active while searching for next event
  921.  
  922.   int cx[4];
  923.   int cy[4];
  924.   int bw = BORDER_W;
  925.   int lw = HEADER_W;
  926.  
  927.   int e = handle_next_event(win,val,x,y);
  928.  
  929.   int x0 = (*win)->x0;
  930.   int y0 = (*win)->y0;
  931.   int x1 = (*win)->x1;
  932.   int y1 = (*win)->y1;
  933.  
  934.  
  935.   cx[0] = x0;
  936.   cy[0] = y0;
  937.   cx[1] = x1-6;
  938.   cy[1] = y0;
  939.   cx[2] = x1-6;
  940.   cy[2] = y1-6;
  941.   cx[3] = x0;
  942.   cy[3] = y1-6;
  943.  
  944.  
  945.   if ( (x0 <= mouse_x && mouse_x <= x0+bw) 
  946.     || (x1 >= mouse_x && mouse_x >= x1-bw)
  947.     || (y0 <= mouse_y && mouse_y <= y0+lw)
  948.     || (y1 >= mouse_y && mouse_y >= y1-bw))
  949.     {
  950.       // pointer on window boundary: move or resize window
  951.  
  952.      if (*win != win_stack[win_top])  /* only top window can be changed  */
  953.      { set_pointer_shape(0);
  954.        return no_event;
  955.       }
  956.  
  957.      for(int i=0; i<4; i++)
  958.        if ( cy[i] <= mouse_y && mouse_y <= cy[i]+6 &&
  959.             cx[i] <= mouse_x && mouse_x <= cx[i]+6 )
  960.        { set_pointer_shape(1);
  961.          if (e == button_press_event && ! (*win)->iconized) 
  962.          { if ((*win)->iconized)
  963.              e = no_event;
  964.            else
  965.              resize_win(*win,x,y,i);
  966.            e = configure_event;
  967.           }
  968.           return e;
  969.         }
  970.  
  971.     set_pointer_shape(0);
  972.    
  973.     if (x0+13 <= mouse_x && mouse_x <= x0+27 &&
  974.         y0+3  <= mouse_y && mouse_y <= y0+15 && e == button_press_event)
  975.     { iconize(*win);
  976.       return ((*win)->iconized) ? no_event : configure_event;
  977.      }
  978.  
  979.  
  980.     if (e== button_press_event) 
  981.     { move_win(*win,x,y);
  982.       if (win_top==1 || (*win)->iconized)  
  983.          return handle_next_event(win,val,x,y);  
  984.       else
  985.          return configure_event;
  986.      }
  987.  
  988.     e = no_event;
  989.  
  990.   }  // if pointer on window boundary
  991.  
  992.   set_pointer_shape(0);
  993.  
  994.   return e;
  995. }
  996.  
  997.  
  998. int get_next_event(Window* win, int* val, int* x, int *y, unsigned long* t)
  999. { // blocking
  1000.   int e = no_event;
  1001.   while (e == no_event) e = check_next_event(win,val,x,y,t);
  1002.   return e;
  1003.  }
  1004.  
  1005.  
  1006.  
  1007. void open_display()
  1008. { REGS regs;
  1009.  
  1010.   if (display) return;
  1011.  
  1012.   display = 1;
  1013.  
  1014.   vga_init(1,root_color);
  1015.  
  1016.   //INT 33 - MS MOUSE - RESET DRIVER AND READ STATUS
  1017.   //    AX = 0000h
  1018.   //Return: AX = status
  1019.   //        0000h hardware/driver not installed
  1020.   //        FFFFh hardware/driver installed
  1021.   //        BX = number of buttons
  1022.   //        FFFFh two buttons
  1023.   //        0000h other than two
  1024.   //        0003h Mouse Systems/Logitech mouse
  1025.   regs.x.ax=0x00;
  1026.   int86(0x33,®s,®s);
  1027.   mouse_installed = (regs.x.ax == 0x0ffff);
  1028.   mouse_two_buttons = (regs.x.bx == 0x0ffff);
  1029.  
  1030.   //INT 33 - MS MOUSE - DEFINE HORIZONTAL CURSOR RANGE = 0..DISP_MAX_X
  1031.   regs.x.ax=0x07;
  1032.   regs.x.cx=0;
  1033.   regs.x.dx=8*DISP_MAX_X;
  1034.   int86(0x33,®s,®s);
  1035.  
  1036.   //INT 33 - MS MOUSE - DEFINE VERTICAL CURSOR RANGE = 0..DISP_MAX_Y
  1037.   regs.x.ax=0x08;
  1038.   regs.x.cx=0;
  1039.   regs.x.dx=8*DISP_MAX_Y;
  1040.   int86(0x33,®s,®s);
  1041.  
  1042.   //INT 33 - MS MOUSE - DEFINE MICKEY/PIXEL RATIO = 1
  1043.   regs.x.ax=0x0F;
  1044.   regs.x.cx=1;
  1045.   regs.x.dx=1;
  1046.   int86(0x33,®s,®s);
  1047.  
  1048.   //INT 33 - MS MOUSE - SET CURSOR POSITION
  1049.   mouse_x = DISP_MAX_X/2;
  1050.   mouse_y = DISP_MAX_Y/2;
  1051.   regs.x.cx = 8*mouse_x;
  1052.   regs.x.dx = 8*mouse_y;
  1053.   regs.x.ax=04;
  1054.   int86(0x33,®s,®s);
  1055.  
  1056.   root_win = new vga_window;
  1057.   win_stack[0] = root_win;
  1058.   win_top = 0;
  1059.  
  1060.   root_win->x0 = -1000;
  1061.   root_win->y0 = -1000;
  1062.   root_win->x1 =  1000;
  1063.   root_win->y1 =  1000;
  1064.   root_win->xpos = 0;
  1065.   root_win->ypos = 0;
  1066.   root_win->width = DISP_WIDTH;
  1067.   root_win->height = DISP_HEIGHT;
  1068.   root_win->bg_col = root_color;
  1069.  
  1070.   set_color(root_color);
  1071.   box(root_win,0,0,DISP_MAX_X,DISP_MAX_Y);
  1072.   set_color(black);
  1073.   //insert_bitmap(root_win,w,h,leda_bits);
  1074. }
  1075.  
  1076.  
  1077.  
  1078. void close_display()
  1079. { union REGS regs;
  1080.   vga_init(0,0);
  1081.   regs.h.ah=0x00;
  1082.   regs.h.al=0x02;
  1083.   int86(0x10,®s,®s);
  1084.   delete root_win;
  1085. }
  1086.  
  1087.  
  1088. void put_header(Window win)
  1089. { char str[80];
  1090.   int n = (win->width - 40)/text_width("H");
  1091.   strncpy(str,win->header,n);
  1092.   str[n] = 0;
  1093.   put_ctext(root_win,win->x0 + win->width/2 + 20, win->y0 + 10 ,str,0);
  1094.  }
  1095.  
  1096. void set_header(Window win, const char* s)
  1097. { int save_co = set_color(win->label_col);
  1098.   int save_mo = set_mode(0);
  1099.   put_header(win);
  1100.   if (s != win->header) strcpy(win->header,s);
  1101.   set_color(1);
  1102.   put_header(win);
  1103.   set_color(save_co);
  1104.   set_mode(save_mo);
  1105.  }
  1106.  
  1107.  
  1108. int  display_width() { return DISP_WIDTH; }
  1109. int  display_height(){ return DISP_HEIGHT; }
  1110. int  display_depth() { return DISP_DEPTH; }
  1111.  
  1112. int  window_width(Window win)  { return win->width; }
  1113. int  window_height(Window win) { return win->height; }
  1114. void window_position(Window win,int* x,int* y) { *x = win->x0; *y = win->y0; }
  1115.  
  1116.